package com.taiyi.renaissancemall.Utils;

import android.content.Context;
import android.content.SharedPreferences;


import androidx.annotation.Nullable;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import java.lang.reflect.Type;
import java.util.Map;
import java.util.Set;

/**
 * author: pearce on 2019-11-12
 * version: v1.0.0
 */
public class SPUtils {
    private SharedPreferences sp;
    private SharedPreferences.Editor editor;

    /**
     * SPUtils 构造函数，需要全局Context
     * @param spName
     */
    public SPUtils(Context context, String spName) {
        sp = context.getSharedPreferences(spName, Context.MODE_PRIVATE);
        editor = sp.edit();
        editor.apply();
    }

    /**
     * SP 中写入String
     * @param key 键
     * @param value 值
     */
    public void putString(String key, @Nullable String value) {
        editor.putString(key, value).apply();
    }

    /**
     * SP 中读取String类型的值
     * @param key 键
     * @return 存在则返回对应值，不存在返回默认值{@code "}
     */
    public String getString(String key) {
        return getString(key, "");
    }

    /**
     * SP 中读取String类型的值
     * @param key 键
     * @param defValue 默认值
     * @return 存在则返回对应值，不存在返回默认值{@code defValue}
     */
    public String getString(String key, @Nullable String defValue) {
        return sp.getString(key, defValue);
    }

    /**
     * SP 中写入int
     * @param key 键
     * @param value 值
     */
    public void putInt(String key, int value) {
        editor.putInt(key, value).apply();
    }

    /**
     * SP 中读取int类型的值
     * @param key 键
     * @return 存在则返回对应值，不存在返回默认值{@code -1}
     */
    public int getInt(String key) {
        return getInt(key, -1);
    }

    /**
     * SP 中读取int类型的值
     * @param key 键
     * @param defValue 默认值
     * @return 存在则返回对应值，不存在返回默认值{@code defValue}
     */
    public int getInt(String key, int defValue) {
        return sp.getInt(key, defValue);
    }

    /**
     * SP 中写入long
     * @param key 键
     * @param value 值
     */
    public void putLong(String key, long value) {
        editor.putLong(key, value).apply();
    }

    /**
     * SP 中读取long类型的值
     * @param key 键
     * @return 存在则返回对应值，不存在返回默认值{@code -1L}
     */
    public long getLong(String key) {
        return getLong(key, -1L);
    }

    /**
     * SP 中读取long类型的值
     * @param key 键
     * @param defValue 默认值
     * @return 存在则返回对应值，不存在返回默认值{@code defValue}
     */
    public long getLong(String key, long defValue) {
        return sp.getLong(key, defValue);
    }

    /**
     * SP 中写入float
     * @param key 键
     * @param value 值
     */
    public void putFloat(String key, Float value) {
        editor.putFloat(key, value).apply();
    }

    /**
     * SP 中读取float类型的值
     * @param key 键
     * @return 存在则返回对应值，不存在返回默认值{@code -1f}
     */
    public float getFloat(String key) {
        return getFloat(key, -1f);
    }

    /**
     * SP 中读取float类型的值
     * @param key 键
     * @param defValue 默认值
     * @return 存在则返回对应值，不存在返回默认值{@code defValue}
     */
    public float getFloat(String key, float defValue) {
        return sp.getFloat(key, defValue);
    }

    /**
     * SP 中写入boolean
     * @param key 键
     * @param value 值
     */
    public void putBoolean(String key, boolean value) {
        editor.putBoolean(key, value).apply();
    }

    /**
     * SP 中读取boolean类型的值
     * @param key 键
     * @return 存在则返回对应值，不存在返回默认值{@code false}
     */
    public boolean getBoolean(String key) {
        return getBoolean(key, false);
    }

    /**
     * SP 中读取boolean类型的值
     * @param key 键
     * @param defValue 默认值
     * @return 存在则返回对应值，不存在返回默认值{@code defValue}
     */
    public boolean getBoolean(String key, boolean defValue) {
        return sp.getBoolean(key, defValue);
    }

    /**
     * SP 中写入String类型set集合value
     * @param key 键
     * @param value 值
     */
    public void putStringSet(String key, Set<String> value) {
        editor.putStringSet(key, value).apply();
    }

    /**
     * SP 中读取StringSet类型的值
     * @param key 键
     * @return 存在则返回对应值，不存在返回默认值{@code null}
     */
    public Set<String> getStringSet(String key) {
        return getStringSet(key, null);
    }

    /**
     * SP 中读取StringSet类型的值
     * @param key 键
     * @param defValue 默认值
     * @return 存在则返回对应值，不存在返回默认值{@code defValue}
     */
    public Set<String> getStringSet(String key, Set<String> defValue) {
        return sp.getStringSet(key, defValue);
    }

    /**
     * 取回preference中所有的值
     * @return map对象
     */
    public Map<String, ?> getAll() {
        return sp.getAll();
    }

    /**
     * 移除preference中所有的值
     */
    public void clear() {
        editor.clear().apply();
    }

    /**
     * 判断SP中是否包含该key
     * @param key 键
     * @return {@code true} 存在  {@code false} 不存在
     */
    public boolean contains(String key) {
        return sp.contains(key);
    }

    /**
     * SP中写入对象
     * @param key 键
     * @param obj 对象
     */
    public void putObject(String key, Object obj) {
        Gson gson = new Gson();
        String json = gson.toJson(obj);
        putString(key, json);
    }

    /**
     * SP 中获取对象
     * @param key
     * @param clazz
     * @return
     */
    public Object getObject(String key, Class<Object> clazz) {
        Gson gson = new Gson();
        String json = getString(key);
        Type type = new TypeToken<Class<Object>>(){}.getType();
        return gson.fromJson(json, type);
    }

    /**
     * SP中移除该key
     *
     * @param key 键
     */
    public void remove(String key) {
        editor.remove(key).apply();
    }


}
